<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js"><span id='Ext-form-Checkbox-method-constructor'><span id='Ext-form-Checkbox'>/**
</span></span> * @class Ext.form.Checkbox
 * @extends Ext.form.Field
 * Single checkbox field.  Can be used as a direct replacement for traditional checkbox fields.
 * @constructor
 * Creates a new Checkbox
 * @param {Object} config Configuration options
 * @xtype checkbox
 */
Ext.form.Checkbox = Ext.extend(Ext.form.Field,  {
<span id='Ext-form-Checkbox-cfg-focusClass'>    /**
</span>     * @cfg {String} focusClass The CSS class to use when the checkbox receives focus (defaults to undefined)
     */
    focusClass : undefined,
<span id='Ext-form-Checkbox-cfg-fieldClass'>    /**
</span>     * @cfg {String} fieldClass The default CSS class for the checkbox (defaults to 'x-form-field')
     */
    fieldClass : 'x-form-field',
<span id='Ext-form-Checkbox-cfg-checked'>    /**
</span>     * @cfg {Boolean} checked &lt;tt&gt;true&lt;/tt&gt; if the checkbox should render initially checked (defaults to &lt;tt&gt;false&lt;/tt&gt;)
     */
    checked : false,
<span id='Ext-form-Checkbox-cfg-boxLabel'>    /**
</span>     * @cfg {String} boxLabel The text that appears beside the checkbox
     */
    boxLabel: '&amp;#160;',
<span id='Ext-form-Checkbox-cfg-autoCreate'>    /**
</span>     * @cfg {String/Object} autoCreate A DomHelper element spec, or true for a default element spec (defaults to
     * {tag: 'input', type: 'checkbox', autocomplete: 'off'})
     */
    defaultAutoCreate : { tag: 'input', type: 'checkbox', autocomplete: 'off'},
<span id='Ext-form-Checkbox-cfg-inputValue'>    /**
</span>     * @cfg {String} inputValue The value that should go into the generated input element's value attribute
     */
<span id='Ext-form-Checkbox-cfg-handler'>    /**
</span>     * @cfg {Function} handler A function called when the {@link #checked} value changes (can be used instead of
     * handling the check event). The handler is passed the following parameters:
     * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
     * &lt;li&gt;&lt;b&gt;checkbox&lt;/b&gt; : Ext.form.Checkbox&lt;div class=&quot;sub-desc&quot;&gt;The Checkbox being toggled.&lt;/div&gt;&lt;/li&gt;
     * &lt;li&gt;&lt;b&gt;checked&lt;/b&gt; : Boolean&lt;div class=&quot;sub-desc&quot;&gt;The new checked state of the checkbox.&lt;/div&gt;&lt;/li&gt;
     * &lt;/ul&gt;&lt;/div&gt;
     */
<span id='Ext-form-Checkbox-cfg-scope'>    /**
</span>     * @cfg {Object} scope An object to use as the scope ('this' reference) of the {@link #handler} function
     * (defaults to this Checkbox).
     */

<span id='Ext-form-Checkbox-property-actionMode'>    // private
</span>    actionMode : 'wrap',

<span id='Ext-form-Checkbox-method-initComponent'>	// private
</span>    initComponent : function(){
        Ext.form.Checkbox.superclass.initComponent.call(this);
        this.addEvents(
<span id='Ext-form-Checkbox-event-check'>            /**
</span>             * @event check
             * Fires when the checkbox is checked or unchecked.
             * @param {Ext.form.Checkbox} this This checkbox
             * @param {Boolean} checked The new checked value
             */
            'check'
        );
    },

<span id='Ext-form-Checkbox-method-onResize'>    // private
</span>    onResize : function(){
        Ext.form.Checkbox.superclass.onResize.apply(this, arguments);
        if(!this.boxLabel &amp;&amp; !this.fieldLabel){
            this.el.alignTo(this.wrap, 'c-c');
        }
    },

<span id='Ext-form-Checkbox-method-initEvents'>    // private
</span>    initEvents : function(){
        Ext.form.Checkbox.superclass.initEvents.call(this);
        this.mon(this.el, {
            scope: this,
            click: this.onClick,
            change: this.onClick
        });
    },

<span id='Ext-form-Checkbox-method-markInvalid'>    /**
</span>     * @hide
     * Overridden and disabled. The editor element does not support standard valid/invalid marking.
     * @method
     */
    markInvalid : Ext.emptyFn,
<span id='Ext-form-Checkbox-method-clearInvalid'>    /**
</span>     * @hide
     * Overridden and disabled. The editor element does not support standard valid/invalid marking.
     * @method
     */
    clearInvalid : Ext.emptyFn,

<span id='Ext-form-Checkbox-method-onRender'>    // private
</span>    onRender : function(ct, position){
        Ext.form.Checkbox.superclass.onRender.call(this, ct, position);
        if(this.inputValue !== undefined){
            this.el.dom.value = this.inputValue;
        }
        this.wrap = this.el.wrap({cls: 'x-form-check-wrap'});
        if(this.boxLabel){
            this.wrap.createChild({tag: 'label', htmlFor: this.el.id, cls: 'x-form-cb-label', html: this.boxLabel});
        }
        if(this.checked){
            this.setValue(true);
        }else{
            this.checked = this.el.dom.checked;
        }
        // Need to repaint for IE, otherwise positioning is broken
        if (Ext.isIEQuirks) {
            this.wrap.repaint();
        }
        this.resizeEl = this.positionEl = this.wrap;
    },

<span id='Ext-form-Checkbox-method-onDestroy'>    // private
</span>    onDestroy : function(){
        Ext.destroy(this.wrap);
        Ext.form.Checkbox.superclass.onDestroy.call(this);
    },

<span id='Ext-form-Checkbox-method-initValue'>    // private
</span>    initValue : function() {
        this.originalValue = this.getValue();
    },

<span id='Ext-form-Checkbox-method-getValue'>    /**
</span>     * Returns the checked state of the checkbox.
     * @return {Boolean} True if checked, else false
     */
    getValue : function(){
        if(this.rendered){
            return this.el.dom.checked;
        }
        return this.checked;
    },

<span id='Ext-form-Checkbox-method-onClick'>	// private
</span>    onClick : function(){
        if(this.el.dom.checked != this.checked){
            this.setValue(this.el.dom.checked);
        }
    },

<span id='Ext-form-Checkbox-method-setValue'>    /**
</span>     * Sets the checked state of the checkbox, fires the 'check' event, and calls a
     * &lt;code&gt;{@link #handler}&lt;/code&gt; (if configured).
     * @param {Boolean/String} checked The following values will check the checkbox:
     * &lt;code&gt;true, 'true', '1', or 'on'&lt;/code&gt;. Any other value will uncheck the checkbox.
     * @return {Ext.form.Field} this
     */
    setValue : function(v){
        var checked = this.checked,
            inputVal = this.inputValue;
            
        if (v === false) {
            this.checked = false;
        } else {
            this.checked = (v === true || v === 'true' || v == '1' || (inputVal ? v == inputVal : String(v).toLowerCase() == 'on'));
        }
        
        if(this.rendered){
            this.el.dom.checked = this.checked;
            this.el.dom.defaultChecked = this.checked;
        }
        if(checked != this.checked){
            this.fireEvent('check', this, this.checked);
            if(this.handler){
                this.handler.call(this.scope || this, this, this.checked);
            }
        }
        return this;
    }
});
Ext.reg('checkbox', Ext.form.Checkbox);
</pre>
</body>
</html>
